--- 模块功能：阿里云功能测试.
-- 支持数据传输和OTA功能
-- @author openLuat
-- @module aLiYun.testALiYun
-- @license MIT
-- @copyright openLuat
-- @release 2018.04.14

require"config"
require"nvm"
require"util"

module(...,package.seeall)

require"pins"
require"aLiYun"
require"misc"
require"pm"
require"ntp"
require"net"
require"misc"
require"common"
local lpack = require"pack"

local base = _G

local shadowVersion = 1
local ALIYUN_PRODUCT_KEY
local ALIYUN_DEVICE_NAME
local ALIYUN_DEVICE_SECRET

local rssi = 0

local allPowerstate = 0
local powerstate = 0
local PowerSwitch_2 = 0
local PowerSwitch_3 = 0
local PowerSwitch_4 = 0

local powerOn_state = 0
local wireless_315_rt = 0
local LocalKeySwitch = 0
local localTestFunc = 1
local oneTestState = 2
local twoTestState = 2

local temperature = 0
local humidity = 0

local setGpioFnc_powerstate = pins.setup(pio.P0_11,0)
local setGpioFnc_PowerSwitch_2 = pins.setup(pio.P0_10,0)
local setGpioFnc_PowerSwitch_3 = pins.setup(pio.P0_12,0)
local setGpioFnc_PowerSwitch_4 = pins.setup(pio.P0_9,0)

local setGpioFnc_powerstate_LED = pins.setup(pio.P0_1,0)
local setGpioFnc_PowerSwitch_2_LED = pins.setup(pio.P0_4,0)
local setGpioFnc_PowerSwitch_3_LED = pins.setup(pio.P0_2,0)
local setGpioFnc_PowerSwitch_4_LED = pins.setup(pio.P0_0,0)

local devRestartFlag = 0

local post_property_x_timeoutid

--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function gpioGDIntFnc(msg)
    log.info("gpioGDIntFnc",msg,getGpioFnc_GD1())
    log.info("gpioGDIntFnc",msg,getGpioFnc_GD2())
    
end

uart.close(2)
getGpioFnc_GD1 = pins.setup(pio.P0_20,gpioGDIntFnc)
getGpioFnc_GD2 = pins.setup(pio.P0_21,gpioGDIntFnc)

--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function updatePowerSwitch()
    setGpioFnc_powerstate_LED(powerstate)
    setGpioFnc_PowerSwitch_2_LED(PowerSwitch_2)
    setGpioFnc_PowerSwitch_3_LED(PowerSwitch_3)
    setGpioFnc_PowerSwitch_4_LED(PowerSwitch_4)

    setGpioFnc_powerstate(powerstate)
    setGpioFnc_PowerSwitch_2(PowerSwitch_2)
    setGpioFnc_PowerSwitch_3(PowerSwitch_3)
    setGpioFnc_PowerSwitch_4(PowerSwitch_4)
end
--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function setPowerSwitchInvert(channel)

    if channel == "powerstate" then
        if powerstate == 0 then
            powerstate = 1

        else
            powerstate = 0
        end

        return powerstate
    end
    if channel == "PowerSwitch_2" then
        if PowerSwitch_2 == 0 then
            PowerSwitch_2 = 1
        else
            PowerSwitch_2 = 0
        end

        return PowerSwitch_2
    end
    if channel == "PowerSwitch_3" then
        if PowerSwitch_3 == 0 then
            PowerSwitch_3 = 1
        else
            PowerSwitch_3 = 0
        end

        return PowerSwitch_3
    end
    if channel == "PowerSwitch_4" then
        if PowerSwitch_4 == 0 then
            PowerSwitch_4 = 1
        else
            PowerSwitch_4 = 0
        end

        return PowerSwitch_4
    end
end
--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function isPowerSwitchAll()
    if powerstate == 0 and PowerSwitch_2 == 0 and PowerSwitch_3 == 0 and PowerSwitch_4 == 0 then
        if allPowerstate == 1 then
            allPowerstate = 0
            app_post_property_onlyAllPowerstate(allPowerstate)
        end
    end  

    if powerstate == 1 and PowerSwitch_2 == 1 and PowerSwitch_3 == 1 and PowerSwitch_4 == 1 then
        if allPowerstate == 0 then
            allPowerstate = 1
            app_post_property_onlyAllPowerstate(allPowerstate)
        end
    end      
end
--[[
函数名：wireless_315_rt
功能  ：
参数  ：无
返回值：
]]
function get_wireless_315_rt()
  return wireless_315_rt
end

--[[
函数名：wireless_315_rt
功能  ：
参数  ：无
返回值：
]]
function set_wireless_315_rt(flag)
    wireless_315_rt = flag

    app_post_property_wireless_315_rt(wireless_315_rt)
end
--[[
函数名：LocalKeySwitch
功能  ：
参数  ：无
返回值：
]]
function get_LocalKeySwitch()
  return LocalKeySwitch
end

--[[
函数名：getDeviceName
功能  ：获取设备名称
参数  ：无
返回值：设备名称
]]
local function getDeviceName()
    --默认使用设备的IMEI作为设备名称，用户可以根据项目需求自行修改    
    --return misc.getImei()
    
    --用户单体测试时，可以在此处直接返回阿里云的iot控制台上注册的设备名称，例如return "862991419835241"
    return ALIYUN_DEVICE_NAME
end

--[[
函数名：setDeviceSecret
功能  ：修改设备密钥
参数  ：设备密钥
返回值：无
]]
local function setDeviceSecret(s)
    --默认使用设备的SN作为设备密钥，用户可以根据项目需求自行修改
    misc.setSn(s)
end


--[[
函数名：getDeviceSecret
功能  ：获取设备密钥
参数  ：无
返回值：设备密钥
]]
local function getDeviceSecret()
    --默认使用设备的SN作为设备密钥，用户可以根据项目需求自行修改
    --return misc.getSn()
    
    --用户单体测试时，可以在此处直接返回阿里云的iot控制台上生成的设备密钥，例如return "y7MTCG6Gk33Ux26bbWSpANl4OaI0bg5Q"
    return ALIYUN_DEVICE_SECRET
end

--阿里云客户端是否处于连接状态
local sConnected

local publishCnt = 1

--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function post_property_x_timeout()
   log.info("post_property_x_timeout") 

   sys.restart("post_property_x_timeout")
end
--[[
函数名：pubqos1ackcb
功能  ：发布1条qos为1的消息后收到PUBACK的回调函数
参数  ：
		usertag：调用mqttclient:publish时传入的usertag
		result：true表示发布成功，false或者nil表示失败
返回值：无
]]
local function pubqos1ackcb(result,para)
    log.info("pubqos1ackcb",result,para)
    publishCnt = publishCnt+1

    --sys.timerStop(post_property_x_timeoutid)
end

--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function app_post_event_x(params)
    local event =
    {
      id = tostring(os.time())..publishCnt,
      version = "v1.0",
      method = "thing.event.{tsl.event.identifier}.post",
      params = params
    }

    local payload = json.encode(event)
    print("event payload:",payload)

    aLiYun.publish("/sys/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName().."/thing/event/{tsl.event.identifier}/post",
                        payload,
                        1,
                        pubqos1ackcb,
                        "event_post"..publishCnt)
end

--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function app_post_property_x(params)
    local property =
    {
      id = tostring(os.time())..publishCnt,
      version = "v1.0",
      method = "thing.event.property.post",
      params = params
    }

    local payload = json.encode(property)
    print("payload:",payload)

    aLiYun.publish("/sys/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName().."/thing/event/property/post",
                        payload,
                        1,
                        pubqos1ackcb,
                        "property_post"..publishCnt)

    --post_property_x_timeoutid = sys.timerStart(post_property_x_timeout,5000)
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_event_hardwareReset(value)

    app_post_event_x({hardwareReset = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_allPowerstate(value)

    app_post_property_x({
            allPowerstate = value,
            powerstate = powerstate,
            PowerSwitch_2 = PowerSwitch_2,
            PowerSwitch_3 = PowerSwitch_3,
            PowerSwitch_4 = PowerSwitch_4,
        })
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_onlyAllPowerstate(value)

    app_post_property_x({
            allPowerstate = value,
        })
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_powerstate(value)

    app_post_property_x({powerstate = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_PowerSwitch_2(value)

    app_post_property_x({PowerSwitch_2 = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_PowerSwitch_3(value)

    app_post_property_x({PowerSwitch_3 = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_PowerSwitch_4(value)

    app_post_property_x({PowerSwitch_4 = value})
end

--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_powerOn_state(value)

    app_post_property_x({powerOn_state = value})
end

--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_temperature(value)

    app_post_property_x({temperature = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_humidity(value)

    app_post_property_x({humidity = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_rssi(value)

    app_post_property_x({rssi = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_wireless_315_rt(value)

    app_post_property_x({wireless_315_rt = value})
end
--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_LocalKeySwitch(value)

    app_post_property_x({LocalKeySwitch = value})
end

--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_localTestFunc(value)

    app_post_property_x({localTestFunc = value})
end

--[[
函数名：
功能  ：主照明
参数  ：
返回值：无
]]
function app_post_property_allTestFuncState()
    log.info("allTestFuncState",allTestFuncState)
    --本地开关检测 0是开启
    if localTestFunc == 0 then
        local GD1 = getGpioFnc_GD1()
        local GD2 = getGpioFnc_GD2()

        log.info("allTestFuncState:",GD1,oneTestState, GD2,twoTestState)

        if oneTestState ~= GD1 or twoTestState ~= GD2 then 
            oneTestState = GD1
            twoTestState = GD2

            app_post_property_x({
                    oneTestState = oneTestState,
                    twoTestState = twoTestState,
                })
        end
        sys.timerStart(app_post_property_allTestFuncState,1000)
    else
        app_post_property_x({
                oneTestState = 2,
                twoTestState = 2,
            })        
    end

end

--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
local function app_post_property_set()
    local tClock = os.date("*t")
    log.info("printTime", 
        string.format("%04d-%02d-%02d %02d:%02d:%02d",tClock.year,tClock.month,tClock.day,tClock.hour,tClock.min,tClock.sec))

    local  post_property_set = {
        allPowerstate = allPowerstate,
        powerstate = powerstate,
        PowerSwitch_2 = PowerSwitch_2,
        PowerSwitch_3 = PowerSwitch_3,
        PowerSwitch_4 = PowerSwitch_4,
        powerOn_state = powerOn_state,
        temperature = temperature,
        humidity = humidity,
        rssi = net.getRssi(),
        DeviceID = misc.getImei(),
        wireless_315_rt = wireless_315_rt,
        LocalKeySwitch = LocalKeySwitch,
        localTestFunc = localTestFunc,
    }

    app_post_property_x(post_property_set)
end
--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function app_recv_property_x(params, post_property)
    for k, v in pairs(params) do
        if k == "allPowerstate" then
            allPowerstate = v
            if allPowerstate == 1 then
                powerstate = 1
                PowerSwitch_2 = 1
                PowerSwitch_3 = 1
                PowerSwitch_4 = 1
            else
                powerstate = 0
                PowerSwitch_2 = 0
                PowerSwitch_3 = 0
                PowerSwitch_4 = 0            
            end

            updatePowerSwitch()

            log.info("allPowerstate",allPowerstate)
            nvm.set("allPowerstate",allPowerstate)
            --if post_property == 1 then
                app_post_property_allPowerstate(allPowerstate)
            --end
        end    
        if k == "LocalKeySwitch" then
            LocalKeySwitch = v
            log.info("LocalKeySwitch",LocalKeySwitch)
            nvm.set("LocalKeySwitch",LocalKeySwitch)
            if post_property == 1 then
                app_post_property_LocalKeySwitch(LocalKeySwitch)
            end
        end
        if k == "powerstate" then
            powerstate = v
            updatePowerSwitch()
            log.info("powerstate",powerstate)
            nvm.set("powerstate",powerstate)
            --if post_property == 1 then
                app_post_property_powerstate(powerstate)
            --end
            isPowerSwitchAll()
        end
        if k == "PowerSwitch_2" then
            PowerSwitch_2 = v
            updatePowerSwitch()
            log.info("PowerSwitch_2",PowerSwitch_2)
            nvm.set("PowerSwitch_2",PowerSwitch_2)
            --if post_property == 1 then
                app_post_property_PowerSwitch_2(PowerSwitch_2)
            --end
            isPowerSwitchAll()
        end
        if k == "PowerSwitch_3" then
            PowerSwitch_3 = v
            updatePowerSwitch()
            log.info("PowerSwitch_3",PowerSwitch_3)
            nvm.set("PowerSwitch_3",PowerSwitch_3)
            --if post_property == 1 then
                app_post_property_PowerSwitch_3(PowerSwitch_3)
            --end
            isPowerSwitchAll()
        end
        if k == "PowerSwitch_4" then
            PowerSwitch_4 = v
            updatePowerSwitch()
            log.info("PowerSwitch_4",PowerSwitch_4)
            nvm.set("PowerSwitch_4",PowerSwitch_4)
            --if post_property == 1 then
                app_post_property_PowerSwitch_4(PowerSwitch_4)
            --end
            isPowerSwitchAll()
        end 
        if k == "powerOn_state" then
            powerOn_state = v
            log.info("powerOn_state",powerOn_state)
            nvm.set("powerOn_state",powerOn_state)
            if post_property == 1 then
                app_post_property_powerOn_state(powerOn_state)
            end
        end 
        if k == "wireless_315_rt" then
            log.info("wireless_315_rt",v)
            if v == 0 then
                wireless_315_rt = 0
                nvm.set("wireless_315_rt",wireless_315_rt)
            end    
            if v == 1 then
                rtKeypad.wireless_315_rt_study()
            end
            if v == 2 then
                rtKeypad.wireless_315_rt_clear()
            end
            if v == 3 then
                wireless_315_rt = 3
                nvm.set("wireless_315_rt",wireless_315_rt)
            end            
        end 
        if k == "localTestFunc" then
            localTestFunc = v
            log.info("localTestFunc",localTestFunc)
            nvm.set("localTestFunc",localTestFunc)
            sys.timerStart(app_post_property_allTestFuncState,1000)
        end 

    end
end

--[[
函数名：
功能  ：
参数  ：
返回值：无
]]
function printApp_post_property(params)

    if rssi ~= net.getRssi() then
       rssi = net.getRssi() 
       app_post_property_rssi(rssi)
    end

end

--每隔1秒输出1次当前模块系统时间
sys.timerLoopStart(printApp_post_property,30000)

---数据接收的处理函数
-- @string topic，UTF8编码的消息主题
-- @number qos，消息质量等级
-- @string payload，原始编码的消息负载
local function rcvCbFnc(topic,qos,payload)
    log.info("testALiYun.rcvCbFnc",topic,qos,payload)

    --RRPC
    if string.find(topic, "/rrpc/request") then

    end
    if string.find(topic, "/thing/service/property/set") then
        local property = json.decode(payload)
        if property ~= nil and type(property) == "table" then
          --for k, v in pairs(property) do
            --print(k..":")
          --end

          local params = property["params"]
          app_recv_property_x(params, 0)
        end
    end
end
--[[
函数名：getdevshadow
功能  ：
参数  ：
返回值：无
]]
function getdevshadow()
  if sConnected == false then
    return
  end

  local msginfo =
  {
    method = "get",
  }  
  local payload = json.encode(msginfo)
  print("getdevshadow:",payload)
  aLiYun.publish("/shadow/update/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName(),payload,1,pubqos1ackcb,"getdevshadow_"..publishCnt)
end
--- 连接结果的处理函数
-- @bool result，连接结果，true表示连接成功，false或者nil表示连接失败
local function connectCbFnc(result)
    log.info("testALiYun.connectCbFnc",result)
    sConnected = result
    if result then
        --订阅主题，不需要考虑订阅结果，如果订阅失败，aLiYun库中会自动重连
        aLiYun.subscribe({["/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName().."/get"]=0, ["/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName().."/get"]=1})
        --注册数据接收的处理函数
        aLiYun.on("receive",rcvCbFnc)
		
		--订阅主题
		--RRPC
		aLiYun.subscribe({["/sys".."/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName().."/rrpc/request/+"]=0, ["/shadow/get/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName()]=0})

        aLiYun.subscribe({["/sys".."/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName().."/thing/service/property/set"]=0})

        aLiYun.subscribe({["/sys".."/"..ALIYUN_PRODUCT_KEY.."/"..getDeviceName().."/thing/event/property/post_reply"]=0})
        --主动获取设备影子
        --getdevshadow()

        app_post_property_set()
        --本地开关检测 0是开启
        sys.timerStart(app_post_property_allTestFuncState,1000)

        log.info("ALiYun poweron_reason",rtos.poweron_reason())
        if devRestartFlag == 0 then
            app_post_event_hardwareReset(0)

            devRestartFlag = 1
        end
    end
end

-- 认证结果的处理函数
-- @bool result，认证结果，true表示认证成功，false或者nil表示认证失败
local function authCbFnc(result)
    log.info("testALiYun.authCbFnc",result)
end

--[[
函数名：init_para
功能  ：
参数  ：无
返回值：无
]]
local function init_para()
  ALIYUN_PRODUCT_KEY = nvm.get("ALIYUN_PRODUCT_KEY")
  ALIYUN_DEVICE_NAME = nvm.get("ALIYUN_DEVICE_NAME")
  ALIYUN_DEVICE_SECRET = nvm.get("ALIYUN_DEVICE_SECRET")
  print("ALIYUN_PRODUCT_KEY:",ALIYUN_PRODUCT_KEY)
  print("ALIYUN_DEVICE_NAME:",ALIYUN_DEVICE_NAME)
  print("ALIYUN_DEVICE_SECRET:",ALIYUN_DEVICE_SECRET)   

  allPowerstate = nvm.get("allPowerstate")
  powerstate = nvm.get("powerstate")
  PowerSwitch_2 = nvm.get("PowerSwitch_2")
  PowerSwitch_3 = nvm.get("PowerSwitch_3")
  PowerSwitch_4 = nvm.get("PowerSwitch_4")
  powerOn_state = nvm.get("powerOn_state")

  wireless_315_rt = nvm.get("wireless_315_rt")
  LocalKeySwitch = nvm.get("LocalKeySwitch")
  localTestFunc = nvm.get("localTestFunc")

  print("Switch_info:",allPowerstate, powerstate, PowerSwitch_2, PowerSwitch_3, PowerSwitch_4, powerOn_state)   
  if rtos.poweron_reason() == 1 then
      if powerOn_state == 1 then
        powerstate = 1
        PowerSwitch_2 = 1
        PowerSwitch_3 = 1
        PowerSwitch_4 = 1
        allPowerstate = 1
      elseif powerOn_state == 2 then
        powerstate = 0
        PowerSwitch_2 = 0
        PowerSwitch_3 = 0
        PowerSwitch_4 = 0
        allPowerstate = 0
      end
  end
  updatePowerSwitch()

  if wireless_315_rt ~= 3 then
    wireless_315_rt = 0
  end
end

nvm.init("config.lua")

init_para()
--采用一机一密认证方案时：
--配置：ProductKey、获取DeviceName的函数、获取DeviceSecret的函数；其中aLiYun.setup中的第二个参数必须传入nil
aLiYun.setup(ALIYUN_PRODUCT_KEY,nil,getDeviceName,getDeviceSecret)

--采用一型一密认证方案时：
--配置：ProductKey、ProductSecret、获取DeviceName的函数、获取DeviceSecret的函数、设置DeviceSecret的函数
--aLiYun.setup(PRODUCT_KEY,PRODUCE_SECRET,getDeviceName,getDeviceSecret,setDeviceSecret)

--setMqtt接口不是必须的，aLiYun.lua中有这个接口设置的参数默认值，如果默认值满足不了需求，参考下面注释掉的代码，去设置参数
--aLiYun.setMqtt(0)
aLiYun.on("auth",authCbFnc)
aLiYun.on("connect",connectCbFnc)
aLiYun.setErrHandle(function() sys.restart("ALIYUN_TASK_INACTIVE") end)

--要使用阿里云OTA功能，必须参考本文件124或者126行aLiYun.setup去配置参数
--然后加载阿里云OTA功能模块(打开下面的代码注释)
require"aLiYunOta"
--如果利用阿里云OTA功能去下载升级合宙模块的新固件，默认的固件版本号格式为：_G.PROJECT.."_".._G.VERSION.."_"..sys.getcorever()，下载结束后，直接重启，则到此为止，不需要再看下文说明


--如果下载升级合宙模块的新固件，下载结束后，自己控制是否重启
--如果利用阿里云OTA功能去下载其他升级包，例如模块外接的MCU升级包，则根据实际情况，打开下面的代码注释，调用设置接口进行配置和处理
--设置MCU当前运行的固件版本号
--aLiYunOta.setVer("MCU_VERSION_1.0.0")
--设置新固件下载后保存的文件名
--aLiYunOta.setName("MCU_FIRMWARE.bin")

--[[
函数名：otaCb
功能  ：新固件文件下载结束后的回调函数
        通过uart1（115200,8,uart.PAR_NONE,uart.STOP_1）把下载成功的文件，发送到MCU，发送成功后，删除此文件
参数  ：
		result：下载结果，true为成功，false为失败
		filePath：新固件文件保存的完整路径，只有result为true时，此参数才有意义
返回值：无
]]
local function otaCb(result,filePath)
    log.info("testALiYun.otaCb",result,filePath)
    if result then
        local uartID = 1
        sys.taskInit(
            function()                
                local fileHandle = io.open(filePath,"rb")
                if not fileHandle then
                    log.error("testALiYun.otaCb open file error")
                    if filePath then os.remove(filePath) end
                    return
                end
                
                pm.wake("UART_SENT2MCU")
                uart.on(uartID,"sent",function() sys.publish("UART_SENT2MCU_OK") end)
                uart.setup(uartID,115200,8,uart.PAR_NONE,uart.STOP_1,nil,1)
                while true do
                    local data = fileHandle:read(1460)
                    if not data then break end
                    uart.write(uartID,data)
                    sys.waitUntil("UART_SENT2MCU_OK")
                end
                --此处上报新固件版本号（仅供测试使用）
                --用户开发自己的程序时，根据下载下来的新固件，执行升级动作
                --升级成功后，调用aLiYunOta.setVer上报新固件版本号
                --如果升级失败，调用aLiYunOta.setVer上报旧固件版本号
                aLiYunOta.setVer("MCU_VERSION_1.0.1")
                
                uart.close(uartID)
                pm.sleep("UART_SENT2MCU")
                fileHandle:close()
                if filePath then os.remove(filePath) end
            end
        )

        
    else
        --文件使用完之后，如果以后不再需求，需要自行删除
        if filePath then os.remove(filePath) end
    end    
end

ntp.timeSync()

